{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import struct\n",
    "from easydict import EasyDict as edict\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import mindspore\n",
    "import mindspore.dataset as ds\n",
    "import mindspore.nn as nn\n",
    "from mindspore import context\n",
    "from mindspore.nn.metrics import Accuracy\n",
    "from mindspore.train import Model\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor\n",
    "from mindspore import Tensor\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='GPU')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "cfg = edict({\n",
    "    'train_size': 60000,  # 训练集大小\n",
    "    'test_size': 10000,  # 测试集大小\n",
    "    'channel': 1,  # 图片通道数\n",
    "    'image_height': 28,  # 图片高度\n",
    "    'image_width': 28,  # 图片宽度\n",
    "    'batch_size': 60,\n",
    "    'num_classes': 10,  # 分类类别\n",
    "    'lr': 0.001,  # 学习率\n",
    "    'epoch_size': 20,  # 训练次数\n",
    "    #此处应该改为自己数据集存储的路径，分别用train和test两个文件夹存储训练数据集和测试数据集\n",
    "    'data_dir_train': os.path.join('./Fashion-MNIST/train/'),\n",
    "    'data_dir_test': os.path.join('./Fashion-MNIST/test/'),\n",
    "    'save_checkpoint_steps': 1,  # 多少步保存一次模型\n",
    "    'keep_checkpoint_max': 3,  # 最多保存多少个模型\n",
    "    'output_directory': './model_fashion',  # 保存模型路径\n",
    "    'output_prefix': \"checkpoint_fashion_forward\"  # 保存模型文件名字\n",
    "})"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "def read_image(file_name):\n",
    "    '''\n",
    "    :param file_name: 文件路径\n",
    "    :return:  训练或者测试数据\n",
    "    如下是训练的图片的二进制格式\n",
    "    [offset] [type]          [value]          [description]\n",
    "    0000     32 bit integer  0x00000803(2051) magic number\n",
    "    0004     32 bit integer  60000            number of images\n",
    "    0008     32 bit integer  28               number of rows\n",
    "    0012     32 bit integer  28               number of columns\n",
    "    0016     unsigned byte   ??               pixel\n",
    "    0017     unsigned byte   ??               pixel\n",
    "    ........\n",
    "    xxxx     unsigned byte   ??               pixel\n",
    "    '''\n",
    "    file_handle = open(file_name, \"rb\")  # 以二进制打开文档\n",
    "    file_content = file_handle.read()  # 读取到缓冲区中\n",
    "    head = struct.unpack_from('>IIII', file_content, 0)  # 取前4个整数，返回一个元组\n",
    "    offset = struct.calcsize('>IIII')\n",
    "    imgNum = head[1]  # 图片数\n",
    "    width = head[2]  # 宽度\n",
    "    height = head[3]  # 高度\n",
    "    bits = imgNum * width * height  # data一共有60000*28*28个像素值\n",
    "    bitsString = '>' + str(bits) + 'B'  # fmt格式：'>47040000B'\n",
    "    imgs = struct.unpack_from(bitsString, file_content, offset)  # 取data数据，返回一个元组\n",
    "    imgs_array = np.array(imgs).reshape((imgNum, width * height))  # 最后将读取的数据reshape成 【图片数，图片像素】二维数组\n",
    "    return imgs_array\n",
    "\n",
    "\n",
    "def read_label(file_name):\n",
    "    '''\n",
    "    :param file_name:\n",
    "    :return:\n",
    "    标签的格式如下：\n",
    "    [offset] [type]          [value]          [description]\n",
    "    0000     32 bit integer  0x00000801(2049) magic number (MSB first)\n",
    "    0004     32 bit integer  60000            number of items\n",
    "    0008     unsigned byte   ??               label\n",
    "    0009     unsigned byte   ??               label\n",
    "    ........\n",
    "    xxxx     unsigned byte   ??               label\n",
    "    The labels values are 0 to 9.\n",
    "    '''\n",
    "    file_handle = open(file_name, \"rb\")  # 以二进制打开文档\n",
    "    file_content = file_handle.read()  # 读取到缓冲区中\n",
    "    head = struct.unpack_from('>II', file_content, 0)  # 取前2个整数，返回一个元组\n",
    "    offset = struct.calcsize('>II')\n",
    "    labelNum = head[1]  # label数\n",
    "    bitsString = '>' + str(labelNum) + 'B'  # fmt格式：'>47040000B'\n",
    "    label = struct.unpack_from(bitsString, file_content, offset)  # 取data数据，返回一个元组\n",
    "    return np.array(label)\n",
    "\n",
    "\n",
    "def get_data():\n",
    "    # 文件获取\n",
    "    train_image = os.path.join(cfg.data_dir_train, 'train-images-idx3-ubyte')\n",
    "    test_image = os.path.join(cfg.data_dir_test, \"t10k-images-idx3-ubyte\")\n",
    "    train_label = os.path.join(cfg.data_dir_train, \"train-labels-idx1-ubyte\")\n",
    "    test_label = os.path.join(cfg.data_dir_test, \"t10k-labels-idx1-ubyte\")\n",
    "    # 读取数据\n",
    "    train_x = read_image(train_image)\n",
    "    test_x = read_image(test_image)\n",
    "    train_y = read_label(train_label)\n",
    "    test_y = read_label(test_label)\n",
    "    return train_x, train_y, test_x, test_y"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/kong/PycharmProjects/pythonProject/fashion\n"
     ]
    }
   ],
   "source": [
    "print(os.getcwd())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练数据集样本数： 60000\n",
      "测试数据集样本数： 10000\n",
      "通道数/图像长/宽： (1, 28, 28)\n",
      "一张图像的标签样式： 9\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_x, train_y, test_x, test_y = get_data()\n",
    "#第一维度是batchsize的数据,第二维度是图像的channel数，第三，第四维度是高和宽\n",
    "train_x = train_x.reshape(-1, 1, cfg.image_height, cfg.image_width)\n",
    "test_x = test_x.reshape(-1, 1, cfg.image_height, cfg.image_width)\n",
    "#归一化至0和1之间\n",
    "train_x = train_x / 255.0\n",
    "test_x = test_x / 255.0\n",
    "#修改数据格式\n",
    "train_x = train_x.astype('float32')\n",
    "test_x = test_x.astype('float32')\n",
    "train_y = train_y.astype('int32')\n",
    "test_y = test_y.astype('int32')\n",
    "print('训练数据集样本数：', train_x.shape[0])\n",
    "print('测试数据集样本数：', test_y.shape[0])\n",
    "print('通道数/图像长/宽：', train_x.shape[1:])\n",
    "print('一张图像的标签样式：', train_y[0])  # 一共10类，用0-9的数字表达类别。\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(train_x[0,0,...])\n",
    "plt.colorbar()\n",
    "plt.grid(False)\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "# 转换数据类型为Dataset\n",
    "XY_train = list(zip(train_x, train_y))\n",
    "#转换数据和标签为dataset类型，并制定数据为x，标签为y\n",
    "ds_train = ds.GeneratorDataset(XY_train, ['x', 'y'])\n",
    "ds_train = ds_train.shuffle(buffer_size=cfg.train_size).batch(cfg.batch_size, drop_remainder=True)\n",
    "XY_test = list(zip(test_x, test_y))\n",
    "ds_test = ds.GeneratorDataset(XY_test, ['x', 'y'])\n",
    "ds_test = ds_test.shuffle(buffer_size=cfg.test_size).batch(cfg.batch_size, drop_remainder=True)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "# 定义前馈神经网络\n",
    "class Forward_fashion(nn.Cell):\n",
    "    def __init__(self, num_class=10):  # 一共分十类，图片通道数是1\n",
    "        super(Forward_fashion, self).__init__()\n",
    "        self.num_class = num_class\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Dense(cfg.channel * cfg.image_height * cfg.image_width, 128)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.fc2 = nn.Dense(128, self.num_class)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 1000, loss is 0.34306326508522034\n",
      "epoch: 2 step: 1000, loss is 0.5107944011688232\n",
      "epoch: 3 step: 1000, loss is 0.25752949714660645\n",
      "epoch: 4 step: 1000, loss is 0.3482718765735626\n",
      "epoch: 5 step: 1000, loss is 0.4153591990470886\n",
      "epoch: 6 step: 1000, loss is 0.2730349898338318\n",
      "epoch: 7 step: 1000, loss is 0.29633045196533203\n",
      "epoch: 8 step: 1000, loss is 0.22608302533626556\n",
      "epoch: 9 step: 1000, loss is 0.25888094305992126\n",
      "epoch: 10 step: 1000, loss is 0.3697953522205353\n",
      "epoch: 11 step: 1000, loss is 0.22604426741600037\n",
      "epoch: 12 step: 1000, loss is 0.3250080943107605\n",
      "epoch: 13 step: 1000, loss is 0.2759271562099457\n",
      "epoch: 14 step: 1000, loss is 0.25047147274017334\n",
      "epoch: 15 step: 1000, loss is 0.2520337402820587\n",
      "epoch: 16 step: 1000, loss is 0.15132944285869598\n",
      "epoch: 17 step: 1000, loss is 0.22934859991073608\n",
      "epoch: 18 step: 1000, loss is 0.14000816643238068\n",
      "epoch: 19 step: 1000, loss is 0.21878933906555176\n",
      "epoch: 20 step: 1000, loss is 0.284330815076828\n"
     ]
    }
   ],
   "source": [
    "# 构建网络\n",
    "network = Forward_fashion(cfg.num_classes)\n",
    "# 定义模型的损失函数，优化器\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "net_opt = nn.Adam(network.trainable_params(), cfg.lr)\n",
    "# 训练模型\n",
    "model = Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={\"acc\"})\n",
    "loss_cb = LossMonitor(per_print_times=int(cfg.train_size / cfg.batch_size))\n",
    "#设定每多少step保存一个checkpoint，并且设定最多保存多少个checkpoint\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=cfg.save_checkpoint_steps,\n",
    "                             keep_checkpoint_max=cfg.keep_checkpoint_max)\n",
    "ckpoint_cb = ModelCheckpoint(prefix=cfg.output_prefix, directory=cfg.output_directory, config=config_ck)\n",
    "print(\"============== Starting Training ==============\")\n",
    "model.train(cfg.epoch_size, ds_train, callbacks=[ckpoint_cb, loss_cb], dataset_sink_mode=False)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'acc': 0.8811244979919679}\n"
     ]
    }
   ],
   "source": [
    "# 使用测试集评估模型，打印总体准确率\n",
    "metric = model.eval(ds_test)\n",
    "print(metric)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第0个sample预测结果： T-shirt/top    真实结果： T-shirt/top\n",
      "第1个sample预测结果： Dress    真实结果： Dress\n",
      "第2个sample预测结果： Ankle boot    真实结果： Ankle boot\n",
      "第3个sample预测结果： Trouser    真实结果： Trouser\n",
      "第4个sample预测结果： Dress    真实结果： Dress\n",
      "第5个sample预测结果： Sneaker    真实结果： Sneaker\n",
      "第6个sample预测结果： Shirt    真实结果： Shirt\n",
      "第7个sample预测结果： T-shirt/top    真实结果： T-shirt/top\n",
      "第8个sample预测结果： Sandal    真实结果： Sandal\n",
      "第9个sample预测结果： Sandal    真实结果： Sandal\n",
      "第10个sample预测结果： Shirt    真实结果： Shirt\n",
      "第11个sample预测结果： Coat    真实结果： Coat\n",
      "第12个sample预测结果： Sneaker    真实结果： Sneaker\n",
      "第13个sample预测结果： Sneaker    真实结果： Ankle boot\n",
      "第14个sample预测结果： Sneaker    真实结果： Sneaker\n"
     ]
    }
   ],
   "source": [
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "\n",
    "#从测试集中取出一组样本，输入模型进行预测\n",
    "test_ = ds_test.create_dict_iterator().__next__()\n",
    "#利用key值选出样本\n",
    "test = Tensor(test_['x'], mindspore.float32)\n",
    "predictions = model.predict(test)\n",
    "softmax = nn.Softmax()\n",
    "predictions = softmax(predictions)\n",
    "predictions = predictions.asnumpy()\n",
    "true_label = test_['y'].asnumpy()\n",
    "\n",
    "for i in range(15):\n",
    "    p_np = predictions[i, :]\n",
    "    pre_label = np.argmax(p_np)\n",
    "    print('第' + str(i) + '个sample预测结果：', class_names[pre_label], '   真实结果：', class_names[true_label[i]])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1200x1000 with 30 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# -------------------定义可视化函数--------------------------------\n",
    "# 输入预测结果序列，真实标签序列，以及图片序列\n",
    "# 目标是根据预测值对错，让其标签显示为红色或者蓝色。对：标签为蓝色；错：标签为红色\n",
    "def plot_image(predicted_label, true_label, img):\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    # 显示对应图片\n",
    "    plt.imshow(img, cmap=plt.cm.binary)\n",
    "    # 显示预测结果的颜色，如果对上了是蓝色，否则为红色\n",
    "    if predicted_label == true_label:\n",
    "        color = 'blue'\n",
    "    else:\n",
    "        color = 'red'\n",
    "    # 显示对应标签的格式，样式\n",
    "    plt.xlabel('{},({})'.format(class_names[predicted_label],\n",
    "                                    class_names[true_label]), color=color)\n",
    "# 将预测的结果以柱状图形状显示蓝对红错\n",
    "def plot_value_array(predicted_label, true_label,predicted_array):\n",
    "    plt.grid(False)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    this_plot = plt.bar(range(10), predicted_array, color='#777777')\n",
    "    plt.ylim([0, 1])\n",
    "    this_plot[predicted_label].set_color('red')\n",
    "    this_plot[true_label].set_color('blue')\n",
    "\n",
    "\n",
    "# 预测15个图像与标签，并展现出来\n",
    "num_rows = 5\n",
    "num_cols = 3\n",
    "num_images = num_rows * num_cols\n",
    "plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))\n",
    "\n",
    "for i in range(num_images):\n",
    "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)\n",
    "    pred_np_ = predictions[i, :]\n",
    "    predicted_label = np.argmax(pred_np_)\n",
    "    image_single = test_['x'][i, 0, ...].asnumpy()\n",
    "    plot_image(predicted_label, true_label[i], image_single)\n",
    "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)\n",
    "    plot_value_array(predicted_label, true_label[i], pred_np_)\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}